packages/extension-polkagate/src/components/ShortAddress.tsx (1)

29-29: Consider using a functional updater for consistency.

For consistency with the improvement made on line 43, the decreaseCharactersCount callback should also use a functional state updater. This prevents potential stale closure issues and aligns with React best practices.

Apply this diff:

-  const decreaseCharactersCount = useCallback(() => clipped && setCharactersCount(charactersCount - 1), [charactersCount, clipped]);
+  const decreaseCharactersCount = useCallback(() => clipped && setCharactersCount((prev) => prev - 1), [clipped]);

packages/extension-polkagate/src/hooks/useProxies.ts (1)

40-40: Improve error handling beyond console logging.

Using console.error provides no user feedback or recovery mechanism. Consider propagating errors to the caller or logging to a monitoring service.

Example approach:

-        }).catch(console.error);
+        }).catch((error) => {
+          console.error('Failed to fetch proxies:', error);
+          // Optionally: set an error state that callers can check
+          // setProxies([]);
+        });

packages/extension-polkagate/src/components/PasswordInput.tsx (2)

66-66: Fix spacing in type annotation.

The type annotation has a missing space after the colon.

Apply this diff:

-  value?:string;
+  value?: string;

---

80-82: Remove unnecessary nullish coalescing operator.

The ?? null in the onChange handler is confusing and serves no purpose. HTMLInputElement.value is always a string (never null or undefined), so the nullish coalescing operator will never trigger. The code should simply pass value directly.

Apply this diff to simplify the onChange handler:

 const onChange = useCallback(({ target: { value } }: React.ChangeEvent<HTMLInputElement>) => {
-  onPassChange(value ?? null);
+  onPassChange(value);
 }, [onPassChange]);

packages/extension-polkagate/src/fullscreen/onboarding/Bread.tsx (1)

77-83: Align the cursor with the disabled state.

While MIGRATE_PASSWORDS reuses the disabled color, the stack still shows a pointer cursor, suggesting it's clickable. Switch the cursor to default for both WELCOME and MIGRATE states to match the navigation guard.

packages/extension-polkagate/src/components/MatchPasswordField.tsx (1)

90-99: Promise handling: prefer await or drop try/catch

try/catch here won’t catch async rejections; you already chain .catch. Either await or remove try/catch.

Suggested:

-  const handleConfirm = useCallback(() => {
+  const handleConfirm = useCallback(async () => {
     if (passwordStatus === PASSWORD_STATUS.MATCHED && onSetPassword) {
-      try {
-        onSetPassword()?.catch(console.error);
-      } catch (error) {
-        console.error('Error setting password:', error);
-      }
+      try {
+        await onSetPassword?.();
+      } catch (error) {
+        console.error('Error setting password:', error);
+      }
     }
-  }, [onSetPassword, passwordStatus]);
+  }, [onSetPassword, passwordStatus]);

packages/extension-polkagate/src/hooks/useCheckMasterPassword.ts (1)

14-24: Redundant isExternal check

You already filter non-external accounts; remove the inner isExternal guard.

-  const results = await Promise.all(nonExternalAccount.map(async (account) => {
-    const { address, isExternal } = account;
-
-    if (isExternal) {
-      return;
-    }
+  const results = await Promise.all(nonExternalAccount.map(async (account) => {
+    const { address } = account;

packages/extension-polkagate/src/util/workers/utils/metadataFromApi.ts (1)

28-40: metaCalls size and schema alignment

• Using full runtimeMetadata increases payload size; calls-only is lighter and commonly used for injection metadata.
• metadataVersion is not part of MetadataDef (in this PR). Either add it to the interface or omit.

Suggested:

-    knownTypes: api.registry.knownTypes,
-    metaCalls: base64Encode(api.runtimeMetadata.toU8a()),
-    metadataVersion: api.runtimeMetadata.version,
-    signedExtensions: api.registry.signedExtensions,
+    knownTypes: api.registry.knownTypes,
+    // keep calls-only to minimize payload
+    metaCalls: base64Encode(api.runtimeMetadata.asCallsOnly.toU8a()),
+    signedExtensions: api.registry.signedExtensions,
@@
-    types: getSpecTypes(api.registry, chainName, api.runtimeVersion.specName, api.runtimeVersion.specVersion) as Record<string, string | Record<string, string>>,
-    userExtensions: (api.registry as any).userExtensions
+    types: getSpecTypes(api.registry, chainName, api.runtimeVersion.specName, api.runtimeVersion.specVersion) as Record<string, string | Record<string, string>>,
+    userExtensions: (api.registry as any).userExtensions

If you need metadataVersion, please add it as an optional field to MetadataDef for consistency.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-polkagate/src/util/api/signAndSend.ts (1)

166-201: Extrinsics that fail now hang and incorrectly report success

This implementation never inspects dispatchError or system.ExtrinsicFailed events, so any on-chain failure (e.g., insufficient balance, module error) is still reported as success: true. Additionally, if the node rejects or drops the extrinsic before it appears in a finalized block, the promise never resolves and the UI hangs indefinitely. The previous send function (lines 93-150) correctly handles dispatch errors via the status callback. Switch to api.rpc.author.submitAndWatchExtrinsic to monitor tx status and events, inspect result.dispatchError to populate failureText and set success: false on failures, and always unsubscribe on terminal states.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-polkagate/src/components/Loading.tsx (1)

93-105: Still normalize the reset URL before allow-listing

Reset routes that carry query strings (/forgot-password?address=...) or nested segments still miss the allow-list because we compare the raw hash via includes. The reset flow stays locked behind the login overlay, same bug as previously reported.

Normalize the hash (strip query/fragment) and compare with some/startsWith so reset URLs continue to work even with params.

-    const extensionUrl = window.location.hash.replace('#', '');
+    const extensionUrl = window.location.hash.replace('#', '');
+    const currentPath = extensionUrl.split(/[?#]/)[0];
     const condition = isExtensionLocked || !children || isFlying;
-    const isResettingWallet = step === STEPS.SHOW_LOGIN && ALLOWED_URL_ON_RESET_PASSWORD.includes(extensionUrl);
+    const isResettingWallet = step === STEPS.SHOW_LOGIN &&
+      ALLOWED_URL_ON_RESET_PASSWORD.some((allowedPath) => currentPath.startsWith(allowedPath));

packages/extension-base/src/background/handlers/Extension.ts (1)

136-145: Lock loop: handle forgotten accounts and purge stale cache entries (duplicate of prior review).

keyring.getPair(address) can throw for forgotten accounts, aborting the loop and leaving other accounts unlocked. Catch and delete the stale cache entry, then continue.

-    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
-      const pair = keyring.getPair(address);
-
-      if (pair && !pair.isLocked) {
-        pair.lock();
-      }
-
-      this.#cachedUnlocks[address] = 0;
-    });
+    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
+      try {
+        const pair = keyring.getPair(address);
+
+        if (!pair.isLocked) {
+          pair.lock();
+        }
+
+        this.#cachedUnlocks[address] = 0;
+      } catch {
+        delete this.#cachedUnlocks[address];
+      }
+    });

packages/extension-polkagate/src/popup/newAccount/createAccountFullScreen/index.tsx (1)

46-46: Remove or document redundant as void on navigate calls.

The codebase consistently annotates navigate(…) with as void, but in React Router v6 navigate already returns void. Unless a specific lint rule or TypeScript setting mandates these assertions, they’re unnecessary. Either drop them or add a comment/guideline explaining why they’re needed.

packages/extension-base/src/background/handlers/Extension.ts (1)

407-437: Unlock‑all: clamp cacheTime and remove debug logs.

• console.log of accounts leaks PII in prod logs.
• cacheTime is unbounded; clamp to a safe max (e.g., PASSWORD_EXPIRY_MS) and validate > 0.

-    console.log('get message to unlock accounts ...');
+    // unlocking multiple accounts with provided password

@@
-    console.log('localAccounts:', localAccounts);
+    // local (non-external) accounts only

@@
-      this.#cachedUnlocks[address] = Date.now() + cacheTime;
+      const safeCache =
+        Number.isFinite(cacheTime) && cacheTime > 0
+          ? Math.min(cacheTime, PASSWORD_EXPIRY_MS)
+          : PASSWORD_EXPIRY_MS;
+      this.#cachedUnlocks[address] = Date.now() + safeCache;

Please confirm whether different per-account passwords are still supported post‑migration; if yes, consider short‑circuiting on the first decodePkcs8 failure and returning false instead of throwing so the caller can surface a friendly error.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-polkagate/src/hooks/useCheckMasterPassword.ts (1)

33-44: Guard against undefined accounts and reset state properly.

This issue was previously flagged but remains unresolved. The current implementation has two problems:

1. Line 40 can call getAccountsNeedsMigration with undefined accounts (when context hasn't loaded yet), causing a runtime error when trying to filter.
2. Lines 34-36 return early when password is missing but don't reset the state, leaving stale migration data visible.

Apply this diff to fix both issues:

   useEffect(() => {
-    if (!pass) {
+    if (!pass || !accounts?.length) {
+      setAccountsNeedMigration(undefined);
       return;
     }
 
     setAccountsNeedMigration(undefined);
 
     getAccountsNeedsMigration(accounts, pass).then((res) => {
       setAccountsNeedMigration(res);
     }).catch(console.error);
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [accounts?.length, pass]);

packages/extension-base/src/background/handlers/Extension.ts (4)

136-145: Guard against missing pairs and clean up stale cache entries.

As previously noted, keyring.getPair(address) throws when an account is forgotten but the cache entry remains. The thrown error aborts the loop, preventing other accounts from being locked.

Apply the previously suggested fix:

-    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
-      const pair = keyring.getPair(address);
-
-      if (pair && !pair.isLocked) {
-        pair.lock();
-      }
-
-      this.#cachedUnlocks[address] = 0;
-    });
+    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
+      try {
+        const pair = keyring.getPair(address);
+
+        if (!pair.isLocked) {
+          pair.lock();
+        }
+
+        this.#cachedUnlocks[address] = 0;
+      } catch (error) {
+        delete this.#cachedUnlocks[address];
+      }
+    });

---

163-163: chrome.tabs.reload does not return a Promise.

As previously flagged, calling .catch on chrome.tabs.reload will throw at runtime since the Chrome API doesn't return a Promise.

Apply the previously suggested fix:

-          chrome.tabs.reload(id).catch(console.error);
+          withErrorLog(() => chrome.tabs.reload(id));

---

451-465: Create a per-request registry instead of mutating the global instance.

As previously noted, mutating the shared global registry can cause race conditions when multiple signing requests are processed concurrently. Each request should use its own isolated TypeRegistry instance.

Apply the previously suggested refactor:

-  private handleRegistry (payload: SignerPayloadJSON): void {
-    // Get the metadata for the genesisHash
-    const currentMetadata = this.metadataGet(payload.genesisHash);
-
-    // set the registry before calling the sign function
-    const signedExtensions = currentMetadata?.signedExtensions?.length
-      ? currentMetadata.signedExtensions
-      : registry.signedExtensions;
-
-    registry.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
-
-    if (currentMetadata) {
-      registry.register(currentMetadata?.types);
-    }
-  }
+  private createSigningRegistry (payload: SignerPayloadJSON): TypeRegistry {
+    const reg = new TypeRegistry();
+    const currentMetadata = this.metadataGet(payload.genesisHash);
+    const signedExtensions = currentMetadata?.signedExtensions?.length
+      ? currentMetadata.signedExtensions
+      : reg.signedExtensions;
+
+    reg.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
+
+    if (currentMetadata?.types) {
+      reg.register(currentMetadata.types);
+    }
+
+    return reg;
+  }

---

521-540: Guard against missing pairs and use a per-request registry.

As previously noted:

1. keyring.getPair(address) can throw for unknown accounts - should return null instead
2. handleRegistry mutates the global registry, causing potential race conditions

Apply the previously suggested fix (adapted for the refactored createSigningRegistry):

 private getSignature ({ payload }: RequestSigninSignature): HexString | null {
   const { address } = payload;

   if (!payload?.address || !payload.genesisHash) {
     throw new Error('Invalid payload: missing required fields.');
   }

+  let pair: KeyringPair;
+
+  try {
+    pair = keyring.getPair(address);
+  } catch {
+    return null;
+  }
-  const pair = keyring.getPair(address);

   this.refreshAccountPasswordCache(pair); // check if auto lock duration is expired

   if (pair.isLocked) {
     return null;
   }

-  this.handleRegistry(payload);
-  const { signature } = registry.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(pair);
+  const reg = this.createSigningRegistry(payload);
+  const { signature } = reg
+    .createType('ExtrinsicPayload', payload, { version: payload.version })
+    .sign(pair);

   return signature;
 }

packages/extension-polkagate/src/fullscreen/settings/partials/AutoLockTimer.tsx (1)

78-78: LGTM! Label change improves clarity.

The label change from "Enable Auto-Lock" to "Adjust Auto-Lock" better reflects that this control manages both the enabled state and timer configuration, not just enabling the feature.

Optional formatting nitpick: Remove the space after the = sign for consistency with standard JSX formatting conventions (label={t('Adjust Auto-Lock')}).

packages/extension-polkagate/src/hooks/index.ts (1)

47-47: Clarify the useIsFlying hook name

Rename useIsFlying to something more descriptive—e.g. useIsInitializing, useIsBooting, or useIsStartingUp—to better convey its purpose.

packages/extension-polkagate/src/hooks/useAutoLock.ts (2)

32-32: Add runtime validation for storage data.

The type assertion as AutoLock|undefined bypasses compile-time type checking. If getStorage returns malformed or unexpected data (e.g., from corrupted storage or version migration), this could lead to runtime issues downstream when the invalid object is used.

Consider adding a type guard or validation function:

+function isValidAutoLock(value: unknown): value is AutoLock {
+  if (!value || typeof value !== 'object') return false;
+  const obj = value as Record<string, unknown>;
+  return (
+    typeof obj.enabled === 'boolean' &&
+    typeof obj.delay === 'object' &&
+    obj.delay !== null &&
+    typeof (obj.delay as Record<string, unknown>).value === 'number' &&
+    ['min', 'hour', 'day'].includes((obj.delay as Record<string, unknown>).type as string)
+  );
+}
+
 useEffect(() => {
   getStorage('autoLock').then((res) => {
-      setAutoLock(res as AutoLock|undefined ?? DEFAULT_AUTO_LOCK);
+      setAutoLock(isValidAutoLock(res) ? res : DEFAULT_AUTO_LOCK);
   }).catch(console.error);

---

35-41: Apply the same validation to storage change events.

The type assertion on line 37 has the same type-safety concern as line 32. The Chrome storage API doesn't enforce type constraints, so newValue should be validated before use.

If you implement the validation guard suggested for line 32, apply it here as well:

 chrome.storage.onChanged.addListener(function (changes, areaName) {
   if (areaName === 'local' && 'autoLock' in changes) {
-    const newValue = changes['autoLock'].newValue as AutoLock;
-
-    setAutoLock(newValue);
+    const newValue = changes['autoLock'].newValue;
+    if (isValidAutoLock(newValue)) {
+      setAutoLock(newValue);
+    }
   }
 });

packages/extension-polkagate/src/popup/settings/partials/actions/Lock.tsx (1)

41-41: Consider using theme colors instead of hardcoded values.

The color logic is now cleaner, but hardcoded hex values '#AA83DC' and '#745D8B' could be replaced with theme constants for better maintainability and consistency.

If your theme defines these purple shades, reference them instead:

-     <Unlock color={isDark ? '#AA83DC' : '#745D8B'} size={18} variant='Bulk' />
+     <Unlock color={theme.palette.primary.light} size={18} variant='Bulk' />

Or add the colors to your theme if they're not already defined.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-base/src/background/handlers/Extension.ts (6)

136-145: Locking fails when cached entry belongs to a forgotten account

keyring.getPair(address) throws once an unlocked account gets forgotten, but we keep the stale cache entry. The thrown error aborts the loop, so the extension never finishes locking remaining accounts (and the request rejects). Please guard missing pairs and purge the stale cache entry before continuing.

-    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
-      const pair = keyring.getPair(address);
-
-      if (pair && !pair.isLocked) {
-        pair.lock();
-      }
-
-      this.#cachedUnlocks[address] = 0;
-    });
+    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
+      try {
+        const pair = keyring.getPair(address);
+
+        if (!pair.isLocked) {
+          pair.lock();
+        }
+
+        this.#cachedUnlocks[address] = 0;
+      } catch (error) {
+        delete this.#cachedUnlocks[address];
+      }
+    });

---

163-163: chrome.tabs.reload does not return a Promise; .catch will throw.

Use the existing withErrorLog helper or a callback to avoid runtime errors.

-          chrome.tabs.reload(id).catch(console.error);
+          withErrorLog(() => chrome.tabs.reload(id));

---

407-443: Handle individual account unlock failures gracefully.

If pair.decodePkcs8(password) throws for any account (e.g., wrong password, corrupted keystore), the entire operation fails and no accounts are unlocked. Consider wrapping the unlock logic in a try-catch to handle failures per account and return partial success information.

-    const res = localAccounts.map(({ address }) => {
-      const pair = keyring.getPair(address);
-
-      if (!pair) {
-        throw new Error('Unable to find pair');
-      }
-
-      if (pair.isLocked) {
-        pair.decodePkcs8(password);
-      }
-
-      this.#cachedUnlocks[address] = Date.now() + cacheTime;
-
-      return true;
-    });
+    const res = localAccounts.map(({ address }) => {
+      try {
+        const pair = keyring.getPair(address);
+
+        if (!pair) {
+          return false;
+        }
+
+        if (pair.isLocked) {
+          pair.decodePkcs8(password);
+        }
+
+        this.#cachedUnlocks[address] = Date.now() + cacheTime;
+
+        return true;
+      } catch (error) {
+        console.error(`Failed to unlock account ${address}:`, error);
+        return false;
+      }
+    });

---

457-471: Avoid global TypeRegistry mutation; create a per-request registry for signing.

Global registry is shared across concurrent requests and may be reconfigured mid‑sign, causing non‑deterministic behavior. Build and use a local registry per payload.

-  private handleRegistry (payload: SignerPayloadJSON): void {
-    // Get the metadata for the genesisHash
-    const currentMetadata = this.metadataGet(payload.genesisHash);
-
-    // set the registry before calling the sign function
-    const signedExtensions = currentMetadata?.signedExtensions?.length
-      ? currentMetadata.signedExtensions
-      : registry.signedExtensions;
-
-    registry.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
-
-    if (currentMetadata) {
-      registry.register(currentMetadata?.types);
-    }
-  }
+  private createSigningRegistry (payload: SignerPayloadJSON): TypeRegistry {
+    const reg = new TypeRegistry();
+    const currentMetadata = this.metadataGet(payload.genesisHash);
+    const signedExtensions = currentMetadata?.signedExtensions?.length
+      ? currentMetadata.signedExtensions
+      : reg.signedExtensions;
+
+    reg.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
+
+    if (currentMetadata?.types) {
+      reg.register(currentMetadata.types);
+    }
+
+    return reg;
+  }

---

506-506: Use the per-request registry from the refactored method.

Once handleRegistry is refactored to createSigningRegistry (returning a local registry), update this call site to use the returned registry for signing instead of the global instance.

-    this.handleRegistry(payload);
+    const reg = this.createSigningRegistry(payload);

Then pass reg to request.sign(reg, pair) on Line 509.

---

527-546: Harden getSignature: handle unknown accounts and use a local registry.

• keyring.getPair(address) can throw; return null instead of throwing.
• Use a per‑request registry to avoid races.
• Remove global registry mutation.

-  private getSignature ({ payload }: RequestSigninSignature): HexString | null {
-    const { address } = payload;
-
-    if (!payload?.address || !payload.genesisHash) {
-      throw new Error('Invalid payload: missing required fields.');
-    }
-
-    const pair = keyring.getPair(address);
-
-    this.refreshAccountPasswordCache(pair); // check if auto lock duration is expired
-
-    if (pair.isLocked) {
-      return null;
-    }
-
-    this.handleRegistry(payload);
-    const { signature } = registry.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(pair);
-
-    return signature;
-  }
+  private getSignature ({ payload }: RequestSigninSignature): HexString | null {
+    if (!payload?.address || !payload.genesisHash) {
+      throw new Error('Invalid payload: missing required fields.');
+    }
+
+    const { address } = payload;
+    let pair: KeyringPair;
+
+    try {
+      pair = keyring.getPair(address);
+    } catch {
+      return null;
+    }
+
+    this.refreshAccountPasswordCache(pair); // check if auto lock duration is expired
+
+    if (pair.isLocked) {
+      return null;
+    }
+
+    const reg = this.createSigningRegistry(payload);
+    const { signature } = reg
+      .createType('ExtrinsicPayload', payload, { version: payload.version })
+      .sign(pair);
+
+    return signature;
+  }

packages/extension-polkagate/src/popup/passwordManagement/Login.tsx (1)

105-109: Resolved: unlocking state now resets via finally

setUnlocking(false) and resetting ref in finally addresses the spinner-stuck issue from the prior review.

packages/extension-base/src/background/handlers/Extension.ts (1)

408-408: Remove debug console.log statements.

Production code should not contain debug logging statements.

-    console.log('get message to unlock accounts ...');

-    console.log('localAccounts:', localAccounts);

Also applies to: 419-419

packages/extension-polkagate/src/popup/passwordManagement/Login.tsx (3)

96-99: Avoid type-cast; use void operator for ignored navigate result

Cleaner and avoids unnecessary casting.

-            : navigate(path) as void;
+            : void navigate(path);

---

85-86: Prefer void operator with error handling over type-cast for setStorage

Suppressing the Promise via cast hides errors; use void and catch.

-            setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true) as unknown as void;
+            void setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true).catch(console.error);

---

156-160: Disable Unlock until prerequisites are ready (better UX)

Prevent no-op Enter/clicks before autoLockPeriod and isPasswordMigrated resolve.

-        disabled={!hashedPassword}
+        disabled={
+          !hashedPassword ||
+          autoLockPeriod === undefined ||
+          isPasswordMigrated === undefined
+        }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-polkagate/src/components/Loading.tsx (1)

102-102: Allow-list should ignore search/hash suffixes.

This is the same issue flagged in the previous review: ALLOWED_URL_ON_RESET_PASSWORD.includes(extensionUrl) only matches exact strings. When routes carry query params (e.g., /forgot-password?address=...), the check fails and the login overlay incorrectly appears, blocking the reset flow.

Apply the previously suggested fix:

-  const isResettingWallet = isForgotten?.status || ALLOWED_URL_ON_RESET_PASSWORD.includes(window.location.hash.replace('#', ''));
+  const extensionUrl = window.location.hash.replace('#', '');
+  const currentPath = extensionUrl.split('?')[0];
+  const isResettingWallet = isForgotten?.status || 
+    ALLOWED_URL_ON_RESET_PASSWORD.some((allowed) => currentPath.startsWith(allowed));

packages/extension-polkagate/src/hooks/useCheckMasterPassword.ts (1)

6-6: Guard undefined/empty accounts, reset state on missing pass, and add cleanup

Avoid calling with undefined/empty accounts, reset state when pass is missing, and prevent stale updates with a cancellation guard. This aligns with the earlier review note.

-import { useContext, useEffect, useState } from 'react';
+import { useContext, useEffect, useMemo, useState } from 'react';
@@
-  const localAccounts = accounts.filter(({ isExternal }) => !isExternal);
+  const localAccounts = useMemo(
+    () => (accounts || []).filter(({ isExternal }) => !isExternal),
+    [accounts]
+  );
@@
   useEffect(() => {
-    if (!pass) {
-      return;
-    }
-
-    setAccountsNeedMigration(undefined);
-
-    getAccountsNeedsMigration(localAccounts, pass).then((res) => {
-      setAccountsNeedMigration(res);
-    }).catch(console.error);
+    if (!pass || !accounts?.length) {
+      setAccountsNeedMigration(undefined);
+      return;
+    }
+
+    let isCurrent = true;
+    setAccountsNeedMigration(undefined);
+
+    void getAccountsNeedsMigration(localAccounts, pass)
+      .then((res) => { if (isCurrent) setAccountsNeedMigration(res); })
+      .catch((e) => { console.error(e); if (isCurrent) setAccountsNeedMigration([]); });
+
+    return () => { isCurrent = false; };
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [accounts?.length, pass]);

Also applies to: 26-26, 30-41

packages/extension-polkagate/src/popup/passwordManagement/Login.tsx (3)

83-96: Clear secrets from state and handle storage Promises explicitly

• Keep plaintext and hash lifetime minimal; clear both after success/migration.
• Don’t discard Promises with a cast; catch errors. Use void to drop result.

         if (success) {
           setExtensionLock(false);
-          hasLocalAccounts && setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true) as unknown as void;
-          setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined) as unknown as void;
+          if (hasLocalAccounts) {
+            void setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true).catch(console.error);
+          }
+          void setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined).catch(console.error);
+          setHashedPassword(undefined);
         } else {
           setExtensionLock(true);
           setIsPasswordError(true);
         }
 
-        setPlainPassword(undefined);
+        setPlainPassword(undefined);
       } else if (accountsNeedMigration?.length && isOldPasswordCorrect) { // needs migration
         await updateStorage(STORAGE_KEY.LOGIN_INFO, { lastLoginTime: Date.now(), status: LOGIN_STATUS.SET }); // DEPRECATED, will be removed in future releases
-        setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined) as unknown as void;
+        void setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined).catch(console.error);
         setHashedPassword(undefined);
+        setPlainPassword(undefined);
         setExtensionLock(false);
         const path = '/migratePasswords';
 
         isExtension
           ? windowOpen(path).catch(console.error)
-          : navigate(path) as void;
+          : void navigate(path);

Also applies to: 100-103

---

51-61: Fix void callback: don’t return setter and clear stale plaintext on empty input

Returning setHashedPassword(...) from a void handler breaks lint and leaves plainPassword stale.

Apply:

 const onPassChange = useCallback((pass: string | null): void => {
   if (!pass) {
-    return setHashedPassword(undefined);
+    setHashedPassword(undefined);
+    setPlainPassword(undefined);
+    return;
   }
 
   setPlainPassword(pass);
   setIsPasswordError(false);
   const hashedPassword = blake2AsHex(pass, 256); // Hash the string with a 256-bit output
 
   setHashedPassword(hashedPassword);
 }, []);

---

125-133: Fix void callback: don’t return setter in onForgotPassword

Returning setStep(...) from a void handler breaks lint.

 const onForgotPassword = useCallback((): void => {
   if (isExtension) {
-    return setStep(STEPS.SHOW_DELETE_ACCOUNT_CONFIRMATION);
+    setStep(STEPS.SHOW_DELETE_ACCOUNT_CONFIRMATION);
+    return;
   }
 
   setStep(STEPS.SHOW_DELETE_ACCOUNT_CONFIRMATION_FS);
   openOrFocusTab('/forgot-password', true);
 }, [isExtension, setStep]);

packages/extension-base/src/background/handlers/Extension.ts (6)

146-155: Lock loop can throw on forgotten/missing pairs; purge stale cache and continue

keyring.getPair(address) may throw if an account was forgotten; this aborts locking the rest.

-    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
-      const pair = keyring.getPair(address);
-
-      if (pair && !pair.isLocked) {
-        pair.lock();
-      }
-
-      this.#cachedUnlocks[address] = 0;
-    });
+    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
+      try {
+        const pair = keyring.getPair(address);
+        if (!pair.isLocked) {
+          pair.lock();
+        }
+        this.#cachedUnlocks[address] = 0;
+      } catch {
+        delete this.#cachedUnlocks[address];
+      }
+    });

---

173-175: chrome.tabs.reload is callback-style; .catch will throw

Use helper or callback to log errors; remove .catch.

-          chrome.tabs.reload(id).catch(console.error);
+          withErrorLog(() => chrome.tabs.reload(id));

---

428-456: Unlock-all should handle per-account failures and continue

A single decodePkcs8 error aborts the whole batch; wrap each attempt to allow partial progress and return aggregate result.

-    try {
-      const accountsLocal = this.localAccounts();
-      const res = accountsLocal.map(({ address }) => {
-        const pair = keyring.getPair(address);
-
-        if (!pair) {
-          throw new Error('Unable to find pair');
-        }
-
-        if (pair.isLocked) {
-          pair.decodePkcs8(password);
-        }
-
-        this.#cachedUnlocks[address] = Date.now() + cacheTime;
-
-        return true;
-      });
-
-      return res.every((success) => success);
-    } catch (error) {
-      console.error('accountsUnlockAll failed:', error);
-
-      return false; // return false if any decode fails
-    }
+    const accountsLocal = this.localAccounts();
+    const res = accountsLocal.map(({ address }) => {
+      try {
+        const pair = keyring.getPair(address);
+        if (pair.isLocked) {
+          pair.decodePkcs8(password);
+        }
+        this.#cachedUnlocks[address] = Date.now() + cacheTime;
+        return true;
+      } catch (error) {
+        console.error(`Failed to unlock ${address}:`, error);
+        return false;
+      }
+    });
+    return res.every(Boolean);

---

459-467: Expiry check ignores local accounts not present in cache

Iterating cache entries only can report expired while some locals remain unlocked/uncached. Check all local accounts.

-    return Object.entries(this.#cachedUnlocks).every(([, time]) => time < Date.now());
+    return accountsLocal.every(({ address }) => {
+      const until = this.#cachedUnlocks[address];
+      return !until || until < Date.now();
+    });

---

469-483: Avoid mutating global TypeRegistry; use a per-request registry

Global registry is shared across requests and can be reconfigured mid-sign. Build a local registry and use it for signing.

Replace handleRegistry with a factory and use it:

-  private handleRegistry (payload: SignerPayloadJSON): void {
+  private createSigningRegistry (payload: SignerPayloadJSON): TypeRegistry {
     const currentMetadata = this.metadataGet(payload.genesisHash);
-    const signedExtensions = currentMetadata?.signedExtensions?.length
-      ? currentMetadata.signedExtensions
-      : registry.signedExtensions;
-
-    registry.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
-
-    if (currentMetadata) {
-      registry.register(currentMetadata?.types);
-    }
-  }
+    const reg = new TypeRegistry();
+    const signedExtensions = currentMetadata?.signedExtensions?.length
+      ? currentMetadata.signedExtensions
+      : reg.signedExtensions;
+    reg.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
+    if (currentMetadata?.types) {
+      reg.register(currentMetadata.types);
+    }
+    return reg;
+  }

And in password-approve path:

-    if (isJsonPayload(payload)) {
-      this.handleRegistry(payload);
-    }
-
-    const result = request.sign(registry, pair);
+    let reg = registry;
+    if (isJsonPayload(payload)) {
+      reg = this.createSigningRegistry(payload);
+    }
+    const result = request.sign(reg, pair);

Also applies to: 517-522

---

539-558: Harden getSignature: validate first, guard getPair, and use local registry

• Don’t destructure before null checks.
• keyring.getPair can throw; return null.
• Use per-request registry, not the shared global.

-  private getSignature ({ payload }: RequestSigninSignature): HexString | null {
-    const { address } = payload;
-
-    if (!payload?.address || !payload.genesisHash) {
-      throw new Error('Invalid payload: missing required fields.');
-    }
-
-    const pair = keyring.getPair(address);
+  private getSignature ({ payload }: RequestSigninSignature): HexString | null {
+    if (!payload?.address || !payload.genesisHash) {
+      throw new Error('Invalid payload: missing required fields.');
+    }
+    const { address } = payload;
+    let pair: KeyringPair;
+    try {
+      pair = keyring.getPair(address);
+    } catch {
+      return null;
+    }
 
     this.refreshAccountPasswordCache(pair); // check if auto lock duration is expired
 
     if (pair.isLocked) {
       return null;
     }
 
-    this.handleRegistry(payload);
-    const { signature } = registry.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(pair);
+    const reg = this.createSigningRegistry(payload);
+    const { signature } = reg.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(pair);
 
     return signature;
   }

packages/extension-polkagate/src/components/Loading.tsx (1)

20-85: Relocate utility functions to a dedicated file.

These storage utility functions (updateStorage, getStorage, watchStorage, setStorage) are exported but defined within a component file. They should be moved to a separate utility module (e.g., util/storage.ts) for better maintainability and reusability.

packages/extension-polkagate/src/fullscreen/home/index.tsx (1)

24-30: Ensure navigation waits for real account data
AccountContext defaults accounts to []—it’s never undefined, so accounts?.length === 0 always fires on mount. Introduce a loading or null‐check (e.g. guard on the raw accounts state) before redirecting to avoid premature onboarding navigation.

packages/extension-polkagate/src/popup/import/importSeedFullScreen/index.tsx (2)

98-101: Handle storage-set errors consistently

Avoid casting away the promise; add error handling like the previous storage write.

-          setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true) as unknown as void;
+          setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true).catch(console.error);

---

208-225: Password entry UX looks good; minor nit

Conditional MatchPasswordField vs PasswordInput is appropriate. Optionally consider passing a controlled value to PasswordInput for consistency with other controlled fields.

packages/extension-polkagate/src/popup/settings/extensionSettings/ManagePassword.tsx (4)

38-39: Avoid name collision with isPasswordCorrect

Shadowing the exported function name is confusing. Alias the hook result and update usages.

-  const { isPasswordCorrect } = useIsPasswordCorrect(oldPass, readyToGo);
+  const { isPasswordCorrect: isOldPassValid } = useIsPasswordCorrect(oldPass, readyToGo);
@@
-    if (!isPasswordCorrect) {
+    if (!isOldPassValid) {
@@
-  }, [isPasswordCorrect, newPass, oldPass, readyToGo, t]);
+  }, [isOldPassValid, newPass, oldPass, readyToGo, t]);

Also applies to: 50-73

---

5-10: Remove legacy storage-based password check helper

With useIsPasswordCorrect and accountsChangePasswordAll in place, the exported isPasswordCorrect helper (LOGIN_INFO + blake2) is obsolete and risks drift. Drop it and clean up imports.

-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
@@
-import useIsPasswordCorrect from '@polkadot/extension-polkagate/src/hooks/useIsPasswordCorrect';
-import { accountsChangePasswordAll } from '@polkadot/extension-polkagate/src/messaging';
-import { getStorage, setStorage } from '@polkadot/extension-polkagate/src/util';
+import useIsPasswordCorrect from '@polkadot/extension-polkagate/src/hooks/useIsPasswordCorrect';
+import { accountsChangePasswordAll } from '@polkadot/extension-polkagate/src/messaging';
+import { setStorage } from '@polkadot/extension-polkagate/src/util';
@@
-import { blake2AsHex } from '@polkadot/util-crypto';
+// (removed blake2 import)
@@
-import { type LoginInfo } from '../../passwordManagement/types';
+// (removed unused LoginInfo type)
@@
-export const isPasswordCorrect = async (password: string, isHashed?: boolean) => {
-  const hashedPassword = isHashed ? password : blake2AsHex(password, 256);
-  const info = await getStorage(STORAGE_KEY.LOGIN_INFO) as LoginInfo;
-
-  return info?.hashedPassword === hashedPassword;
-};
+// removed legacy isPasswordCorrect()

Also applies to: 14-18, 20-25

---

86-93: Optional: make current password field controlled

Keeps state in sync and simplifies debugging.

-          <PasswordInput
+          <PasswordInput
+            value={oldPass}
             focused
             hasError={passwordError}
             onPassChange={onCurrentPasswordChange}
             style={{ marginBottom: '18px' }}
             title={t('Current Password')}
           />

---

93-99: Remove ts-ignore by fixing MatchPasswordField prop types

Don’t suppress types. Update MatchPasswordField’s onSetPassword signature to accept a no-arg callback (or the expected type) and drop the ts-ignore.

packages/extension-polkagate/src/components/PasswordInput.tsx (1)

80-83: Simplify onChange

Value is always a string; remove the null coalescing for clarity.

-  const onChange = useCallback(({ target: { value } }: React.ChangeEvent<HTMLInputElement>) => {
-    onPassChange(value ?? null);
-  }, [onPassChange]);
+  const onChange = useCallback(({ target: { value } }: React.ChangeEvent<HTMLInputElement>) => {
+    onPassChange(value);
+  }, [onPassChange]);

packages/extension-polkagate/src/hooks/useIsPasswordCorrect.ts (1)

22-35: Prevent stale state updates; add cleanup and narrow deps

Add a cancellation guard to avoid setting state after unmount/race, use firstLocal.address directly, and narrow deps.

   useEffect(() => {
     setCorrect(undefined);

     if (!password || ready === false || !firstLocal) {
       return;
     }

-    accountsValidate(localAccounts[0].address, password).then((status) => {
-      setCorrect(status);
-    }).catch((error) => {
-      console.error(error);
-      setCorrect(false);
-    });
-  }, [firstLocal, localAccounts, password, ready]);
+    let isCurrent = true;
+    void accountsValidate(firstLocal.address, password)
+      .then((status) => { if (isCurrent) setCorrect(status); })
+      .catch((error) => { console.error(error); if (isCurrent) setCorrect(false); });
+
+    return () => { isCurrent = false; };
+  }, [firstLocal?.address, password, ready]);

packages/extension-polkagate/src/fullscreen/settings/partials/Password.tsx (1)

26-36: Robust timestamp parsing and placeholder

Handle numeric/string timestamps safely and fix the placeholder format.

-    getStorage(STORAGE_KEY.LAST_PASS_CHANGE).then((timestamp) => {
-      if (timestamp) {
-        const date = new Date(timestamp as unknown as number);
+    getStorage(STORAGE_KEY.LAST_PASS_CHANGE).then((timestamp) => {
+      const ms = Number(timestamp);
+      if (Number.isFinite(ms) && ms > 0) {
+        const date = new Date(ms);
@@
-              <Typography color='text.secondary' variant='B-5'>
-                {lastEditDate ?? '__,__,__'}
+              <Typography color='text.secondary' variant='B-5'>
+                {lastEditDate ?? '__.__.__'}

Also applies to: 73-73

packages/extension-polkagate/src/messaging.ts (1)

84-87: Avoid duplicate wrappers for the same message

Both accountsValidate and validateAccount call pri(accounts.validate). This duplicates API surface and invites confusion.

Options:

• Prefer accountsValidate and remove validateAccount, or
• Re-export for backward compat:

-export async function validateAccount (address: string, password: string): Promise<boolean> {
-  return sendMessage('pri(accounts.validate)', { address, password });
-}
+// Deprecated: use accountsValidate
+export const validateAccount = accountsValidate;

Also applies to: 125-127

packages/extension-polkagate/src/popup/passwordManagement/MigratePasswords.tsx (2)

146-149: Remove ts-ignore by aligning callback type

Avoid // @ts-ignore on MatchPasswordField. If it expects a parameter, wrap your handler to accept and ignore it, or update prop typing.

Example:

-            // @ts-ignore
-            onSetPassword={onContinue}
+            onSetPassword={(): void => onContinue()}

Or adjust MatchPasswordField prop type to accept () => void as well.

---

56-58: Prefer void navigate(...) and clear secrets on completion

Minor cleanup for intent clarity; also clear in-memory passwords when done.

-      navigate('/') as void;
+      void navigate('/');

   setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true)
     .then(() => {
       setExtensionLock(true);
-      navigate('/') as void;
-      lockExtension().catch(console.error);
+      void navigate('/');
+      void lockExtension().catch(console.error);
+      // minimize secret lifetime
+      setCurrentPass('');
+      setMasterPass(undefined);
     }).catch(console.error);

Also applies to: 101-106

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-polkagate/src/fullscreen/settings/partials/Password.tsx (1)

26-26: Consider safer type handling for timestamp.

The double cast as unknown as number bypasses type safety. If the stored value is a string representation of a timestamp, the Date constructor will handle it, but this defeats TypeScript's type checking.

Consider one of these approaches:

Option 1: Type guard with explicit conversion

-        const date = new Date(timestamp as unknown as number);
+        const timestampNum = typeof timestamp === 'number' ? timestamp : parseInt(String(timestamp), 10);
+        const date = new Date(timestampNum);

Option 2: Let Date constructor handle it (it accepts string | number)

-        const date = new Date(timestamp as unknown as number);
+        const date = new Date(timestamp as string | number);

Option 3: Update getStorage return type to include number in its signature (if timestamps are always stored as numbers).

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/extension-polkagate/src/popup/import/importRawSeedFullScreen/index.tsx (1)

41-53: Critical: Validation persists keys to storage.

The keyring.addUri method persists keys to the keyring as a side effect. Validation should be pure and not mutate storage. Additionally, the error message is not translated.

Use the background validateSeed method instead:

+import { validateSeed as validateSeedBg } from '../../../messaging';
+
 const validateSeed = useCallback(async (seed: string, type?: KeypairType): Promise<AccountInfo> => {
   if (!(seed.startsWith('0x') && seed.length === 66)) {
-    throw new Error('The raw seed is invalid. It should be 66 characters long and start with 0x');
+    throw new Error(t('The raw seed is invalid. It should be 66 characters long and start with 0x'));
   }
 
-  const { pair } = keyring.addUri(seed, undefined, {}, type || DEFAULT_TYPE);
+  const { address, suri } = await validateSeedBg(seed, type || DEFAULT_TYPE);
 
   return {
-    address: pair.address,
+    address,
     genesis: POLKADOT_GENESIS,
-    suri: seed
+    suri
   };
-}, []);
+}, [t]);

packages/extension-polkagate/src/hooks/useCheckMasterPassword.ts (1)

29-41: Guard on falsy pass and add cancellation to avoid stale state updates

• When pass becomes falsy, previous results linger; reset state and return early.
• Cancel in‑flight validations when pass or localAccounts change to prevent late resolves overwriting newer state.

   useEffect(() => {
-    if (!pass) {
-      return;
-    }
-
-    setAccountsNeedMigration(undefined);
-
-    getAccountsNeedsMigration(localAccounts, pass)
-      .then(setAccountsNeedMigration)
-      .catch(console.error);
+    if (!pass) {
+      setAccountsNeedMigration(undefined);
+      return;
+    }
+
+    setAccountsNeedMigration(undefined);
+
+    let cancelled = false;
+    void getAccountsNeedsMigration(localAccounts, pass)
+      .then((res) => {
+        if (!cancelled) setAccountsNeedMigration(res);
+      })
+      .catch((e) => {
+        console.error(e);
+        if (!cancelled) setAccountsNeedMigration([]);
+      });
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [localAccounts?.length, pass]);
+    return () => { cancelled = true; };
+  }, [localAccounts?.length, pass]);

packages/extension-polkagate/src/popup/passwordManagement/Login.tsx (2)

128-133: LGTM: void callback no longer returns a value

The early return now avoids returning the setter result.

---

86-96: Clear hashed password on success to minimize secret lifetime

plainPassword is cleared, but hashedPassword remains in memory after a successful unlock.

           if (success) {
             setExtensionLock(false);
-            hasLocalAccounts && setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true) as unknown as void;
-            setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined) as unknown as void;
+            if (hasLocalAccounts) {
+              void setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true).catch(console.error);
+            }
+            void setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined).catch(console.error);
           } else {
             setExtensionLock(true);
             setIsPasswordError(true);
           }
 
-          setPlainPassword(undefined);
+          setPlainPassword(undefined);
+          setHashedPassword(undefined);

packages/extension-base/src/background/handlers/Extension.ts (7)

174-175: LGTM: use withErrorLog for chrome.tabs.reload

Avoids .catch on a non‑Promise API and logs lastError safely.

---

145-155: Locking can throw for forgotten accounts; purge stale cache and continue

keyring.getPair(address) may throw after an account is forgotten; the loop aborts and remaining accounts aren’t locked.

-    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
-      const pair = keyring.getPair(address);
-
-      if (pair && !pair.isLocked) {
-        pair.lock();
-      }
-
-      this.#cachedUnlocks[address] = 0;
-    });
+    Object.entries(this.#cachedUnlocks).forEach(([address]) => {
+      try {
+        const pair = keyring.getPair(address);
+        if (!pair.isLocked) {
+          pair.lock();
+        }
+        this.#cachedUnlocks[address] = 0;
+      } catch {
+        delete this.#cachedUnlocks[address];
+      }
+    });

---

433-461: Handle per‑account unlock failures without aborting the whole operation

A single bad keystore/password currently flips the entire result to false. Capture failures per account and keep going.

-    try {
-      const accountsLocal = this.localAccounts();
-      const res = accountsLocal.map(({ address }) => {
-        const pair = keyring.getPair(address);
-
-        if (!pair) {
-          throw new Error('Unable to find pair');
-        }
-
-        if (!pair.isLocked) {
-          pair.lock();
-        }
-
-        if (pair.isLocked) {
-          pair.decodePkcs8(password);
-        }
-
-        this.#cachedUnlocks[address] = Date.now() + cacheTime;
-
-        return true;
-      });
-
-      return res.every((success) => success);
-    } catch (error) {
-      console.error('accountsUnlockAll failed:', error);
-
-      return false; // return false if any decode fails
-    }
+    const accountsLocal = this.localAccounts();
+    const results = accountsLocal.map(({ address }) => {
+      try {
+        const pair = keyring.getPair(address);
+        if (!pair.isLocked) pair.lock();
+        if (pair.isLocked) pair.decodePkcs8(password);
+        this.#cachedUnlocks[address] = Date.now() + cacheTime;
+        return true;
+      } catch (error) {
+        console.error(`accountsUnlockAll: failed to unlock ${address}`, error);
+        return false;
+      }
+    });
+
+    return results.every(Boolean);

---

463-471: areLocksExpired ignores accounts without cache entries

Iterate local accounts and treat missing cache entries as expired.

-    return Object.entries(this.#cachedUnlocks).every(([, time]) => time < Date.now());
+    return accountsLocal.every(({ address }) => {
+      const time = this.#cachedUnlocks[address];
+      return !time || time < Date.now();
+    });

---

473-487: Avoid mutating the global TypeRegistry; create a per‑request registry

Global registry mutation is a race across concurrent requests; use a local registry instead.

-  private handleRegistry (payload: SignerPayloadJSON): void {
-    // Get the metadata for the genesisHash
-    const currentMetadata = this.metadataGet(payload.genesisHash);
-
-    // set the registry before calling the sign function
-    const signedExtensions = currentMetadata?.signedExtensions?.length
-      ? currentMetadata.signedExtensions
-      : registry.signedExtensions;
-
-    registry.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
-
-    if (currentMetadata) {
-      registry.register(currentMetadata?.types);
-    }
-  }
+  private createSigningRegistry (payload: SignerPayloadJSON): TypeRegistry {
+    const reg = new TypeRegistry();
+    const currentMetadata = this.metadataGet(payload.genesisHash);
+    const signedExtensions = currentMetadata?.signedExtensions?.length
+      ? currentMetadata.signedExtensions
+      : reg.signedExtensions;
+    reg.setSignedExtensions(signedExtensions, currentMetadata?.userExtensions);
+    if (currentMetadata?.types) {
+      reg.register(currentMetadata.types);
+    }
+    return reg;
+  }

---

543-562: Harden getSignature and sign with a local registry

Handle unknown accounts and avoid global registry mutation.

   private getSignature ({ payload }: RequestSigningSignature): HexString | null {
     if (!payload?.address || !payload.genesisHash) {
       throw new Error('Invalid payload: missing required fields.');
     }
 
-    const { address } = payload;
-
-    const pair = keyring.getPair(address);
-
-    this.refreshAccountPasswordCache(pair); // check if auto lock duration is expired
-
-    if (pair.isLocked) {
-      return null;
-    }
-
-    this.handleRegistry(payload);
-    const { signature } = registry.createType('ExtrinsicPayload', payload, { version: payload.version }).sign(pair);
+    const { address } = payload;
+    let pair: KeyringPair;
+    try {
+      pair = keyring.getPair(address);
+    } catch {
+      return null;
+    }
+
+    this.refreshAccountPasswordCache(pair);
+    if (pair.isLocked) {
+      return null;
+    }
+
+    const reg = this.createSigningRegistry(payload);
+    const { signature } = reg
+      .createType('ExtrinsicPayload', payload, { version: payload.version })
+      .sign(pair);
 
     return signature;
   }

---

92-100: Gracefully handle per‑account failures in accountsChangePasswordAll

One failure currently throws and aborts the whole request; return overall success while logging failures.

   private accountsChangePasswordAll ({ newPass, oldPass }: RequestAccountChangePasswordAll): boolean {
     const accountsLocal = this.localAccounts();
 
-    const res = accountsLocal.map(({ address }) => {
-      return this.accountsChangePassword({ address, newPass, oldPass });
-    });
+    const res = accountsLocal.map(({ address }) => {
+      try {
+        return this.accountsChangePassword({ address, newPass, oldPass });
+      } catch (e) {
+        console.error(`accountsChangePasswordAll: failed for ${address}`, e);
+        return false;
+      }
+    });
 
     return res.every(Boolean);
   }

packages/extension-base/src/background/types.ts (2)

121-123: LGTM: consistent naming RequestSigningSignature

The request/response map uses the corrected name.

---

361-364: LGTM: RequestUnlockAllAccounts placed before Responses with clear comment

Interface is in the Requests section and uses “milliseconds”.

packages/extension-polkagate/src/popup/passwordManagement/MigratePasswords.tsx (3)

53-56: Don’t return a setter from useEffect

Returning setStep(...) is a no‑op and confuses the effect’s cleanup semantics.

-    if (accountsNeedMigration?.length) {
-      return setStep(STEP.MIGRATING);
-    }
+    if (accountsNeedMigration?.length) {
+      setStep(STEP.MIGRATING);
+      return;
+    }

---

185-192: Normalize PasswordInput nulls before updating string state

PasswordInput passes string | null; writing null into string state is unsafe.

-                  onPassChange={setCurrentPass}
+                  onPassChange={(pass) => setCurrentPass(pass ?? '')}

---

37-39: Align masterPass type with initialization

Avoid string | undefined but initialize with ''. Pick one convention.

-  const [masterPass, setMasterPass] = useState<string | undefined>('');
+  const [masterPass, setMasterPass] = useState<string>('');

packages/extension-polkagate/src/popup/staking/solo-new/settings/ChooseAccount.tsx (1)

60-60: Consider using a stable identifier for the Fragment key.

The Fragment currently uses index as the key, which can cause issues if the accounts list is reordered or filtered. Consider using address or formatted instead, as they provide stable unique identifiers.

Apply this diff:

-              <Fragment key={index}>
+              <Fragment key={address}>
                 <Container disableGutters onClick={handleSelect(formatted)} sx={{ alignItems: 'center', cursor: 'pointer', display: 'flex', flexDirection: 'row', justifyContent: 'space-between' }}>

packages/extension-polkagate/src/popup/import/importRawSeedFullScreen/index.tsx (1)

168-186: Recommended: Always pass onImport to avoid race conditions.

Conditionally passing undefined to onSetPassword based on parent state can race with child component updates. If the user presses Enter while the parent hasn't updated, the action may silently no-op.

Let MatchPasswordField gate the action based on its own validation state:

-            {localAccounts?.length === 0
-              ? (<MatchPasswordField
-                onSetPassword={(password && name && !error && !!seed) ? onImport : undefined}
+            {localAccounts?.length === 0
+              ? (<MatchPasswordField
+                onSetPassword={onImport}
                 setConfirmedPassword={setPassword}
                 spacing='20px'

packages/extension-polkagate/src/popup/passwordManagement/Login.tsx (2)

88-90: Avoid casting Promises to void; handle rejections explicitly

Replace as unknown as void with a safe fire‑and‑forget pattern.

-            hasLocalAccounts && setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true) as unknown as void;
-            setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined) as unknown as void;
+            if (hasLocalAccounts) {
+              void setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true).catch(console.error);
+            }
+            void setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined).catch(console.error);
@@
-          setHashedPassword(undefined);
+          setHashedPassword(undefined);
+          void setStorage(STORAGE_KEY.IS_FORGOTTEN, undefined).catch(console.error);

Also applies to: 98-101

---

103-106: Prefer void navigate(path) over as void cast

Minor readability/style improvement.

-          isExtension
-            ? windowOpen(path).catch(console.error)
-            : navigate(path) as void;
+          isExtension
+            ? windowOpen(path).catch(console.error)
+            : void navigate(path);

packages/extension-polkagate/src/popup/passwordManagement/MigratePasswords.tsx (2)

99-108: Clear sensitive state on completion

Unset masterPass/currentPassword in memory once migration is finalized.

   const onDone = useCallback(() => {
     setIsBusy(true);
 
     setStorage(STORAGE_KEY.IS_PASSWORD_MIGRATED, true)
       .then(() => {
         setExtensionLock(true);
-        navigate('/') as void;
+        navigate('/') as void;
         lockExtension().catch(console.error);
-      }).catch(console.error);
+      }).catch(console.error)
+      .finally(() => {
+        // minimize secret lifetime
+        // eslint-disable-next-line no-unused-expressions
+        setCurrentPass('');
+        // eslint-disable-next-line no-unused-expressions
+        // masterPass is used only for this flow; clear it
+        // @ts-expect-error: allowed for secret clearing
+        setMasterPass('');
+      });
   }, [navigate, setExtensionLock]);

---

70-97: Ensure isBusy resets in all paths

Use finally to guarantee setIsBusy(false) regardless of success/error/early exit.

   const onNext = useCallback(() => {
     if (accountToMigrate && masterPass) {
-      setIsBusy(true);
-      accountsChangePassword(accountToMigrate.address, currentPassword, masterPass)
-        .then((success) => {
+      setIsBusy(true);
+      accountsChangePassword(accountToMigrate.address, currentPassword, masterPass)
+        .then((success) => {
           if (success) {
             if (accountIndexToChangePassword + 1 === accountsNeedMigration?.length) {
-              setIsBusy(false);
-
-              return setStep(STEP.COMPLETED);
+              setStep(STEP.COMPLETED);
+              return;
             }
 
             setAccountIndex((pre) => pre + 1);
             setCurrentPass('');
           } else {
             notify(t('Something went wrong while migrating password!'), 'error');
           }
-          setIsBusy(false);
         }).catch((error) => {
           console.error(error);
           setIncorrectPassword(true);
-          setIsBusy(false);
-        });
+        }).finally(() => setIsBusy(false));
     } else {
-      setIsBusy(false);
+      setIsBusy(false);
     }
   }, [accountIndexToChangePassword, accountToMigrate, accountsNeedMigration?.length, currentPassword, masterPass, notify, t]);